/*
 * File      : dc_draw.h
 * This file is part of RT-Thread GUI Engine
 * COPYRIGHT (C) 2006 - 2017, RT-Thread Development Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Change Logs:
 * Date           Author       Notes
 * 2013-10-04     Bernard      porting SDL software render to RT-Thread GUI
 */

/*
  Simple DirectMedia Layer
  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>

  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not
     claim that you wrote the original software. If you use this software
     in a product, an acknowledgment in the product documentation would be
     appreciated but is not required.
  2. Altered source versions must be plainly marked as such, and must not be
     misrepresented as being the original software.
  3. This notice may not be removed or altered from any source distribution.
*/

#ifndef __DC_DRAW_H__
#define __DC_DRAW_H__

#include <rtgui/blit.h>

/* This code assumes that r, g, b, a are the source color,
 * and in the blend and add case, the RGB values are premultiplied by a.
 */

#define DRAW_MUL(_a, _b) (((unsigned)(_a)*(_b))/256)

#define DRAW_FASTSETPIXEL(type) \
    *pixel = (type) color

#define DRAW_FASTSETPIXEL1 DRAW_FASTSETPIXEL(rt_uint8_t)
#define DRAW_FASTSETPIXEL2 DRAW_FASTSETPIXEL(rt_uint16_t)
#define DRAW_FASTSETPIXEL3 \
    do { \
        rt_uint8_t *p = (rt_uint8_t *)pixel; \
        *p++ = ((color & 0xFF0000) >> 16); \
        *p++ = ((color & 0xFF00) >> 8); \
        *p = (color & 0xFF); \
    } while (0)

#define DRAW_FASTSETPIXEL4 DRAW_FASTSETPIXEL(rt_uint32_t)

#define DRAW_FASTSETPIXELXY(x, y, type, bpp, color) \
    *(type *)(_dc_get_pixel(dst, x, y))= (type) color

#define DRAW_FASTSETPIXELXY1(x, y) DRAW_FASTSETPIXELXY(x, y, rt_uint8_t, 1, color)
#define DRAW_FASTSETPIXELXY2(x, y) DRAW_FASTSETPIXELXY(x, y, rt_uint16_t, 2, color)
#define DRAW_FASTSETPIXELXY3(x, y) \
	do{ \
	    rt_uint8_t *p = (rt_uint8_t *)(_dc_get_pixel(dst, x, y)); \
	    *p++ = ((color & 0xFF0000) >> 16); \
	    *p++ = ((color & 0xFF00) >> 8); \
	    *p = (color & 0xFF); \
	} while (0)
	
#define DRAW_FASTSETPIXELXY4(x, y) DRAW_FASTSETPIXELXY(x, y, rt_uint32_t, 4, color)

#define DRAW_SETPIXEL(setpixel) \
do { \
    unsigned sr = r, sg = g, sb = b, sa = a; (void) sa; \
    setpixel; \
} while (0)

#define DRAW_SETPIXEL_BLEND(getpixel, setpixel) \
do { \
    unsigned sr, sg, sb, sa; (void) sa; \
    getpixel; \
    sr = DRAW_MUL(inva, sr) + r; \
    sg = DRAW_MUL(inva, sg) + g; \
    sb = DRAW_MUL(inva, sb) + b; \
    setpixel; \
} while (0)

#define DRAW_SETPIXEL_ADD(getpixel, setpixel) \
do { \
    unsigned sr, sg, sb, sa; (void) sa; \
    getpixel; \
    sr += r; if (sr > 0xff) sr = 0xff; \
    sg += g; if (sg > 0xff) sg = 0xff; \
    sb += b; if (sb > 0xff) sb = 0xff; \
    setpixel; \
} while (0)

#define DRAW_SETPIXEL_MOD(getpixel, setpixel) \
do { \
    unsigned sr, sg, sb, sa; (void) sa; \
    getpixel; \
    sr = DRAW_MUL(sr, r); \
    sg = DRAW_MUL(sg, g); \
    sb = DRAW_MUL(sb, b); \
    setpixel; \
} while (0)

#define DRAW_SETPIXELXY(x, y, type, bpp, op) \
do { \
    type *pixel = (type *)(_dc_get_pixel(dst, x, y));\
    op; \
} while (0)

/*
 * Define draw operators for RGB555
 */

#define DRAW_SETPIXEL_RGB555 \
    DRAW_SETPIXEL(RGB555_FROM_RGB(*pixel, sr, sg, sb))

#define DRAW_SETPIXEL_BLEND_RGB555 \
    DRAW_SETPIXEL_BLEND(RGB_FROM_RGB555(*pixel, sr, sg, sb), \
                        RGB555_FROM_RGB(*pixel, sr, sg, sb))

#define DRAW_SETPIXEL_ADD_RGB555 \
    DRAW_SETPIXEL_ADD(RGB_FROM_RGB555(*pixel, sr, sg, sb), \
                      RGB555_FROM_RGB(*pixel, sr, sg, sb))

#define DRAW_SETPIXEL_MOD_RGB555 \
    DRAW_SETPIXEL_MOD(RGB_FROM_RGB555(*pixel, sr, sg, sb), \
                      RGB555_FROM_RGB(*pixel, sr, sg, sb))

#define DRAW_SETPIXELXY_RGB555(x, y) \
    DRAW_SETPIXELXY(x, y, rt_uint16_t, 2, DRAW_SETPIXEL_RGB555)

#define DRAW_SETPIXELXY_BLEND_RGB555(x, y) \
    DRAW_SETPIXELXY(x, y, rt_uint16_t, 2, DRAW_SETPIXEL_BLEND_RGB555)

#define DRAW_SETPIXELXY_ADD_RGB555(x, y) \
    DRAW_SETPIXELXY(x, y, rt_uint16_t, 2, DRAW_SETPIXEL_ADD_RGB555)

#define DRAW_SETPIXELXY_MOD_RGB555(x, y) \
    DRAW_SETPIXELXY(x, y, rt_uint16_t, 2, DRAW_SETPIXEL_MOD_RGB555)

/*
 * Define draw operators for RGB565
 */

#define DRAW_SETPIXEL_RGB565 \
    DRAW_SETPIXEL(RGB565_FROM_RGB(*pixel, sr, sg, sb))

#define DRAW_SETPIXEL_BLEND_RGB565 \
    do { \
        unsigned sr, sg, sb; \
        RGB_FROM_RGB565(*pixel, sr, sg, sb); \
        sr = ((r * a) + (inva * sr)) * 257 >> 16; \
        sg = ((g * a) + (inva * sg)) * 257 >> 16; \
        sb = ((b * a) + (inva * sb)) * 257 >> 16; \
        RGB565_FROM_RGB(*pixel, sr, sg, sb); \
    } while (0)

#define DRAW_SETPIXEL_ADD_RGB565 \
    DRAW_SETPIXEL_ADD(RGB_FROM_RGB565(*pixel, sr, sg, sb), \
                      RGB565_FROM_RGB(*pixel, sr, sg, sb))

#define DRAW_SETPIXEL_MOD_RGB565 \
    DRAW_SETPIXEL_MOD(RGB_FROM_RGB565(*pixel, sr, sg, sb), \
                      RGB565_FROM_RGB(*pixel, sr, sg, sb))

#define DRAW_SETPIXELXY_RGB565(x, y) \
    DRAW_SETPIXELXY(x, y, rt_uint16_t, 2, DRAW_SETPIXEL_RGB565)

#define DRAW_SETPIXELXY_BLEND_RGB565(x, y) \
    DRAW_SETPIXELXY(x, y, rt_uint16_t, 2, DRAW_SETPIXEL_BLEND_RGB565)

#define DRAW_SETPIXELXY_ADD_RGB565(x, y) \
    DRAW_SETPIXELXY(x, y, rt_uint16_t, 2, DRAW_SETPIXEL_ADD_RGB565)

#define DRAW_SETPIXELXY_MOD_RGB565(x, y) \
    DRAW_SETPIXELXY(x, y, rt_uint16_t, 2, DRAW_SETPIXEL_MOD_RGB565)

/*
 * Define draw operators for BGR565
 */

#define DRAW_SETPIXEL_BGR565 \
    DRAW_SETPIXEL(BGR565_FROM_RGB(*pixel, sr, sg, sb))

#define DRAW_SETPIXEL_BLEND_BGR565 \
    DRAW_SETPIXEL_BLEND(RGB_FROM_BGR565(*pixel, sr, sg, sb), \
                        BGR565_FROM_RGB(*pixel, sr, sg, sb))

#define DRAW_SETPIXEL_ADD_BGR565 \
    DRAW_SETPIXEL_ADD(RGB_FROM_BGR565(*pixel, sr, sg, sb), \
                      BGR565_FROM_RGB(*pixel, sr, sg, sb))

#define DRAW_SETPIXEL_MOD_BGR565 \
    DRAW_SETPIXEL_MOD(RGB_FROM_BGR565(*pixel, sr, sg, sb), \
                      BGR565_FROM_RGB(*pixel, sr, sg, sb))

#define DRAW_SETPIXELXY_BGR565(x, y) \
    DRAW_SETPIXELXY(x, y, rt_uint16_t, 2, DRAW_SETPIXEL_BGR565)

#define DRAW_SETPIXELXY_BLEND_BGR565(x, y) \
    DRAW_SETPIXELXY(x, y, rt_uint16_t, 2, DRAW_SETPIXEL_BLEND_BGR565)

#define DRAW_SETPIXELXY_ADD_BGR565(x, y) \
    DRAW_SETPIXELXY(x, y, rt_uint16_t, 2, DRAW_SETPIXEL_ADD_BGR565)

#define DRAW_SETPIXELXY_MOD_BGR565(x, y) \
    DRAW_SETPIXELXY(x, y, rt_uint16_t, 2, DRAW_SETPIXEL_MOD_BGR565)

/*
 * Define draw operators for RGB888
 */

#define DRAW_SETPIXEL_RGB888 \
    DRAW_SETPIXEL(RGB888_FROM_RGB(*pixel, sr, sg, sb))

#define DRAW_SETPIXEL_BLEND_RGB888 \
    do { \
        unsigned sr, sg, sb; \
        RGB_FROM_RGB888(*pixel, sr, sg, sb); \
        sr = ((r * a) + (inva * sr)) >> 8; \
        sg = ((g * a) + (inva * sg)) >> 8; \
        sb = ((b * a) + (inva * sb)) >> 8; \
        RGB888_FROM_RGB(*pixel, sr, sg, sb); \
    } while (0)

#define DRAW_SETPIXEL_ADD_RGB888 \
    DRAW_SETPIXEL_ADD(RGB_FROM_RGB888(*pixel, sr, sg, sb), \
                      RGB888_FROM_RGB(*pixel, sr, sg, sb))

#define DRAW_SETPIXEL_MOD_RGB888 \
    DRAW_SETPIXEL_MOD(RGB_FROM_RGB888(*pixel, sr, sg, sb), \
                      RGB888_FROM_RGB(*pixel, sr, sg, sb))

#ifdef PKG_USING_RGB888_PIXEL_BITS_32
#define DRAW_SETPIXELXY_RGB888(x, y) \
    DRAW_SETPIXELXY(x, y, rt_uint32_t, 4, DRAW_SETPIXEL_RGB888)
#else
#define DRAW_SETPIXELXY_RGB888(x, y) \
    DRAW_SETPIXELXY(x, y, rt_uint8_t, 3, DRAW_SETPIXEL_RGB888)
#endif

#ifdef PKG_USING_RGB888_PIXEL_BITS_32
#define DRAW_SETPIXELXY_BLEND_RGB888(x, y) \
    DRAW_SETPIXELXY(x, y, rt_uint32_t, 4, DRAW_SETPIXEL_BLEND_RGB888)
#else
#define DRAW_SETPIXELXY_BLEND_RGB888(x, y) \
    DRAW_SETPIXELXY(x, y, rt_uint8_t, 3, DRAW_SETPIXEL_BLEND_RGB888)
#endif

#ifdef PKG_USING_RGB888_PIXEL_BITS_32
#define DRAW_SETPIXELXY_ADD_RGB888(x, y) \
    DRAW_SETPIXELXY(x, y, rt_uint32_t, 4, DRAW_SETPIXEL_ADD_RGB888)
#else
#define DRAW_SETPIXELXY_ADD_RGB888(x, y) \
    DRAW_SETPIXELXY(x, y, rt_uint8_t, 3, DRAW_SETPIXEL_ADD_RGB888)
#endif

#ifdef PKG_USING_RGB888_PIXEL_BITS_32
#define DRAW_SETPIXELXY_MOD_RGB888(x, y) \
    DRAW_SETPIXELXY(x, y, rt_uint32_t, 4, DRAW_SETPIXEL_MOD_RGB888)
#else
#define DRAW_SETPIXELXY_MOD_RGB888(x, y) \
    DRAW_SETPIXELXY(x, y, rt_uint8_t, 3, DRAW_SETPIXEL_MOD_RGB888)
#endif

/*
 * Define draw operators for ARGB8888
 */

#define DRAW_SETPIXEL_ARGB8888 \
    DRAW_SETPIXEL(ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))

#define DRAW_SETPIXEL_BLEND_ARGB8888 \
    do { \
        unsigned sr, sg, sb, sa; \
        RGBA_FROM_ARGB8888(*pixel, sr, sg, sb, sa); \
        if (sa) \
        {   \
            sa = a + (inva * sa + 128) / 255; \
            sr = ((r * a) + (inva * sr)) >> 8; \
            sg = ((g * a) + (inva * sg)) >> 8; \
            sb = ((b * a) + (inva * sb)) >> 8; \
        }   \
        else \
        { \
            sa = a; \
            sr = r; \
            sg = g; \
            sb = g; \
        } \
        ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa); \
    } while (0)

#define DRAW_SETPIXEL_ADD_ARGB8888 \
    DRAW_SETPIXEL_ADD(RGBA_FROM_ARGB8888(*pixel, sr, sg, sb, sa), \
                      ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))

#define DRAW_SETPIXEL_MOD_ARGB8888 \
    DRAW_SETPIXEL_MOD(RGBA_FROM_ARGB8888(*pixel, sr, sg, sb, sa), \
                      ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))

#define DRAW_SETPIXELXY_ARGB8888(x, y) \
    DRAW_SETPIXELXY(x, y, rt_uint32_t, 4, DRAW_SETPIXEL_ARGB8888)

#define DRAW_SETPIXELXY_BLEND_ARGB8888(x, y) \
    DRAW_SETPIXELXY(x, y, rt_uint32_t, 4, DRAW_SETPIXEL_BLEND_ARGB8888)

#define DRAW_SETPIXELXY_ADD_ARGB8888(x, y) \
    DRAW_SETPIXELXY(x, y, rt_uint32_t, 4, DRAW_SETPIXEL_ADD_ARGB8888)

#define DRAW_SETPIXELXY_MOD_ARGB8888(x, y) \
    DRAW_SETPIXELXY(x, y, rt_uint32_t, 4, DRAW_SETPIXEL_MOD_ARGB8888)

/*
 * Define line drawing macro
 */

#define ABS(_x) ((_x) < 0 ? -(_x) : (_x))

/* Horizontal line */
#define HLINE(type, op, draw_end) \
{ \
    int length; \
    int inc_size = _UI_BITBYTES(_dc_get_bits_per_pixel(dst)) / sizeof(type); \
    type *pixel; \
    if (x1 <= x2) { \
        pixel = (type *)_dc_get_pixel(dst, x1, y1); \
        length = draw_end ? (x2-x1+1) : (x2-x1); \
    } else { \
        pixel = (type *)_dc_get_pixel(dst, x2, y1); \
        if (!draw_end) { \
            pixel += inc_size; \
        } \
        length = draw_end ? (x1-x2+1) : (x1-x2); \
    } \
    while (length--) { \
        op; \
        pixel += inc_size; \
    } \
}

/* Vertical line */
#define VLINE(type, op, draw_end) \
{ \
    int length; \
    int inc_size = _UI_BITBYTES(_dc_get_bits_per_pixel(dst)); \
    int pitch = _dc_get_pitch(dst) / inc_size; \
    type *pixel; \
    inc_size = inc_size / sizeof(type); \
    if (y1 <= y2) { \
        pixel = (type *)_dc_get_pixel(dst, x1, y1); \
        length = draw_end ? (y2-y1+1) : (y2-y1); \
    } else { \
        pixel = (type *)_dc_get_pixel(dst, x1, y2); \
        if (!draw_end) { \
            pixel += pitch * inc_size; \
        } \
        length = draw_end ? (y1-y2+1) : (y1-y2); \
    } \
    while (length--) { \
        op; \
        pixel += pitch * inc_size; \
    } \
}

/* Diagonal line */
#define DLINE(type, op, draw_end) \
{ \
    int length; \
    int inc_size = _UI_BITBYTES(_dc_get_bits_per_pixel(dst)); \
    int pitch = _dc_get_pitch(dst) / inc_size; \
    type *pixel; \
    inc_size = inc_size / sizeof(type); \
    if (y1 <= y2) { \
        pixel = (type *)_dc_get_pixel(dst, x1, y1); \
        if (x1 <= x2) { \
            ++pitch; \
        } else { \
            --pitch; \
        } \
        length = (y2-y1); \
    } else { \
        pixel = (type *)_dc_get_pixel(dst, x2, y2); \
        if (x2 <= x1) { \
            ++pitch; \
        } else { \
            --pitch; \
        } \
        if (!draw_end) { \
            pixel += pitch * inc_size; \
        } \
        length = (y1-y2); \
    } \
    if (draw_end) { \
        ++length; \
    } \
    while (length--) { \
        op; \
        pixel += pitch * inc_size; \
    } \
}

/* Bresenham's line algorithm */
#define BLINE(x1, y1, x2, y2, op, draw_end) \
{ \
    int i, deltax, deltay, numpixels; \
    int d, dinc1, dinc2; \
    int x, xinc1, xinc2; \
    int y, yinc1, yinc2; \
 \
    deltax = ABS(x2 - x1); \
    deltay = ABS(y2 - y1); \
 \
    if (deltax >= deltay) { \
        numpixels = deltax + 1; \
        d = (2 * deltay) - deltax; \
        dinc1 = deltay * 2; \
        dinc2 = (deltay - deltax) * 2; \
        xinc1 = 1; \
        xinc2 = 1; \
        yinc1 = 0; \
        yinc2 = 1; \
    } else { \
        numpixels = deltay + 1; \
        d = (2 * deltax) - deltay; \
        dinc1 = deltax * 2; \
        dinc2 = (deltax - deltay) * 2; \
        xinc1 = 0; \
        xinc2 = 1; \
        yinc1 = 1; \
        yinc2 = 1; \
    } \
 \
    if (x1 > x2) { \
        xinc1 = -xinc1; \
        xinc2 = -xinc2; \
    } \
    if (y1 > y2) { \
        yinc1 = -yinc1; \
        yinc2 = -yinc2; \
    } \
 \
    x = x1; \
    y = y1; \
 \
    if (!draw_end) { \
        --numpixels; \
    } \
    for (i = 0; i < numpixels; ++i) { \
        op(x, y); \
        if (d < 0) { \
            d += dinc1; \
            x += xinc1; \
            y += yinc1; \
        } else { \
            d += dinc2; \
            x += xinc2; \
            y += yinc2; \
        } \
    } \
}

/* Xiaolin Wu's line algorithm, based on Michael Abrash's implementation */
#define WULINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end) \
{ \
    rt_uint16_t ErrorAdj, ErrorAcc; \
    rt_uint16_t ErrorAccTemp, Weighting; \
    int DeltaX, DeltaY, Temp, XDir; \
    unsigned r, g, b, a, inva; \
	\
	/* remove compiling warning */ \
	r = 0; g = 0; b = 0; a = 0; \
	inva = 0; inva = inva; \
    /* Draw the initial pixel, which is always exactly intersected by \
       the line and so needs no weighting */ \
    opaque_op(x1, y1); \
	\
    /* Draw the final pixel, which is always exactly intersected by the line \
       and so needs no weighting */ \
    if (draw_end) { \
        opaque_op(x2, y2); \
    } \
	\
    /* Make sure the line runs top to bottom */ \
    if (y1 > y2) { \
        Temp = y1; y1 = y2; y2 = Temp; \
        Temp = x1; x1 = x2; x2 = Temp; \
    } \
    DeltaY = y2 - y1; \
 \
    if ((DeltaX = x2 - x1) >= 0) { \
        XDir = 1; \
    } else { \
        XDir = -1; \
        DeltaX = -DeltaX; /* make DeltaX positive */ \
    } \
 \
    /* line is not horizontal, diagonal, or vertical */ \
    ErrorAcc = 0;  /* initialize the line error accumulator to 0 */ \
 \
    /* Is this an X-major or Y-major line? */ \
    if (DeltaY > DeltaX) { \
        /* Y-major line; calculate 16-bit fixed-point fractional part of a \
          pixel that X advances each time Y advances 1 pixel, truncating the \
          result so that we won't overrun the endpoint along the X axis */ \
        ErrorAdj = ((unsigned long) DeltaX << 16) / (unsigned long) DeltaY; \
        /* Draw all pixels other than the first and last */ \
        while (--DeltaY) { \
            ErrorAccTemp = ErrorAcc;   /* remember current accumulated error */ \
            ErrorAcc += ErrorAdj;      /* calculate error for next pixel */ \
            if (ErrorAcc <= ErrorAccTemp) { \
                /* The error accumulator turned over, so advance the X coord */ \
                x1 += XDir; \
            } \
            y1++; /* Y-major, so always advance Y */ \
            /* The IntensityBits most significant bits of ErrorAcc give us the \
             intensity weighting for this pixel, and the complement of the \
             weighting for the paired pixel */ \
            Weighting = ErrorAcc >> 8; \
            { \
                a = DRAW_MUL(_a, (Weighting ^ 255)); \
                r = DRAW_MUL(_r, a); \
                g = DRAW_MUL(_g, a); \
                b = DRAW_MUL(_b, a); \
                inva = (a ^ 0xFF); \
                blend_op(x1, y1); \
            } \
            { \
                a = DRAW_MUL(_a, Weighting); \
                r = DRAW_MUL(_r, a); \
                g = DRAW_MUL(_g, a); \
                b = DRAW_MUL(_b, a); \
                inva = (a ^ 0xFF); \
                blend_op(x1 + XDir, y1); \
            } \
        } \
    } else { \
        /* X-major line; calculate 16-bit fixed-point fractional part of a \
           pixel that Y advances each time X advances 1 pixel, truncating the \
           result to avoid overrunning the endpoint along the X axis */ \
        ErrorAdj = ((unsigned long) DeltaY << 16) / (unsigned long) DeltaX; \
        /* Draw all pixels other than the first and last */ \
        while (--DeltaX) { \
            ErrorAccTemp = ErrorAcc;   /* remember currrent accumulated error */ \
            ErrorAcc += ErrorAdj;      /* calculate error for next pixel */ \
            if (ErrorAcc <= ErrorAccTemp) { \
                /* The error accumulator turned over, so advance the Y coord */ \
                y1++; \
            } \
            x1 += XDir; /* X-major, so always advance X */ \
            /* The IntensityBits most significant bits of ErrorAcc give us the \
              intensity weighting for this pixel, and the complement of the \
              weighting for the paired pixel */ \
            Weighting = ErrorAcc >> 8; \
            { \
                a = DRAW_MUL(_a, (Weighting ^ 255)); \
                r = DRAW_MUL(_r, a); \
                g = DRAW_MUL(_g, a); \
                b = DRAW_MUL(_b, a); \
                inva = (a ^ 0xFF); \
                blend_op(x1, y1); \
            } \
            { \
                a = DRAW_MUL(_a, Weighting); \
                r = DRAW_MUL(_r, a); \
                g = DRAW_MUL(_g, a); \
                b = DRAW_MUL(_b, a); \
                inva = (a ^ 0xFF); \
                blend_op(x1, y1 + 1); \
            } \
        } \
    } \
}

#define AALINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end) \
            WULINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end)

/*
 * Define fill rect macro
 */
#define FILLRECT(type, op) \
do { \
    int width = rect->x2 - rect->x1; \
    int height = rect->y2 - rect->y1; \
    int inc_size = _UI_BITBYTES(_dc_get_bits_per_pixel(dst)); \
    int pitch = _dc_get_pitch(dst) / inc_size; \
    int skip = pitch - width; \
    type *pixel = (type *)_dc_get_pixel(dst, rect->x1, rect->y1); \
    inc_size = inc_size / sizeof(type); \
    while (height--) { \
        { int n = (width+3)/4; \
            switch (width & 3) { \
            case 0: do {   op; pixel += inc_size; \
            case 3:        op; pixel += inc_size; \
            case 2:        op; pixel += inc_size; \
            case 1:        op; pixel += inc_size; \
                    } while ( --n > 0 ); \
            } \
        } \
        pixel += skip * inc_size; \
    } \
} while (0)

#endif
